{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ssms\n",
    "import lanfactory\n",
    "import os\n",
    "import numpy as np\n",
    "from copy import deepcopy\n",
    "import torch\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "MODEL = \"ddm\"\n",
    "RUN_SIMS = False\n",
    "DEVICE = \"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function export in module torch.onnx.utils:\n",
      "\n",
      "export(model: 'Union[torch.nn.Module, torch.jit.ScriptModule, torch.jit.ScriptFunction]', args: 'Union[Tuple[Any, ...], torch.Tensor]', f: 'Union[str, io.BytesIO]', export_params: 'bool' = True, verbose: 'bool' = False, training: '_C_onnx.TrainingMode' = <TrainingMode.EVAL: 0>, input_names: 'Optional[Sequence[str]]' = None, output_names: 'Optional[Sequence[str]]' = None, operator_export_type: '_C_onnx.OperatorExportTypes' = <OperatorExportTypes.ONNX: 0>, opset_version: 'Optional[int]' = None, do_constant_folding: 'bool' = True, dynamic_axes: 'Optional[Union[Mapping[str, Mapping[int, str]], Mapping[str, Sequence[int]]]]' = None, keep_initializers_as_inputs: 'Optional[bool]' = None, custom_opsets: 'Optional[Mapping[str, int]]' = None, export_modules_as_functions: 'Union[bool, Collection[Type[torch.nn.Module]]]' = False, autograd_inlining: 'Optional[bool]' = True) -> 'None'\n",
      "    Exports a model into ONNX format.\n",
      "    \n",
      "    If ``model`` is not a :class:`torch.jit.ScriptModule` nor a\n",
      "    :class:`torch.jit.ScriptFunction`, this runs\n",
      "    ``model`` once in order to convert it to a TorchScript graph to be exported\n",
      "    (the equivalent of :func:`torch.jit.trace`). Thus this has the same limited support\n",
      "    for dynamic control flow as :func:`torch.jit.trace`.\n",
      "    \n",
      "    Args:\n",
      "        model (:class:`torch.nn.Module`, :class:`torch.jit.ScriptModule` or :class:`torch.jit.ScriptFunction`):\n",
      "            the model to be exported.\n",
      "        args (tuple or torch.Tensor):\n",
      "    \n",
      "            args can be structured either as:\n",
      "    \n",
      "            1. ONLY A TUPLE OF ARGUMENTS::\n",
      "    \n",
      "                args = (x, y, z)\n",
      "    \n",
      "            The tuple should contain model inputs such that ``model(*args)`` is a valid\n",
      "            invocation of the model. Any non-Tensor arguments will be hard-coded into the\n",
      "            exported model; any Tensor arguments will become inputs of the exported model,\n",
      "            in the order they occur in the tuple.\n",
      "    \n",
      "            2. A TENSOR::\n",
      "    \n",
      "                args = torch.Tensor([1])\n",
      "    \n",
      "            This is equivalent to a 1-ary tuple of that Tensor.\n",
      "    \n",
      "            3. A TUPLE OF ARGUMENTS ENDING WITH A DICTIONARY OF NAMED ARGUMENTS::\n",
      "    \n",
      "                args = (\n",
      "                    x,\n",
      "                    {\n",
      "                        \"y\": input_y,\n",
      "                        \"z\": input_z\n",
      "                    }\n",
      "                )\n",
      "    \n",
      "            All but the last element of the tuple will be passed as non-keyword arguments,\n",
      "            and named arguments will be set from the last element. If a named argument is\n",
      "            not present in the dictionary, it is assigned the default value, or None if a\n",
      "            default value is not provided.\n",
      "    \n",
      "            .. note::\n",
      "                If a dictionary is the last element of the args tuple, it will be\n",
      "                interpreted as containing named arguments. In order to pass a dict as the\n",
      "                last non-keyword arg, provide an empty dict as the last element of the args\n",
      "                tuple. For example, instead of::\n",
      "    \n",
      "                    torch.onnx.export(\n",
      "                        model,\n",
      "                        (\n",
      "                            x,\n",
      "                            # WRONG: will be interpreted as named arguments\n",
      "                            {y: z}\n",
      "                        ),\n",
      "                        \"test.onnx.pb\"\n",
      "                    )\n",
      "    \n",
      "                Write::\n",
      "    \n",
      "                    torch.onnx.export(\n",
      "                        model,\n",
      "                        (\n",
      "                            x,\n",
      "                            {y: z},\n",
      "                            {}\n",
      "                        ),\n",
      "                        \"test.onnx.pb\"\n",
      "                    )\n",
      "    \n",
      "        f: a file-like object (such that ``f.fileno()`` returns a file descriptor)\n",
      "            or a string containing a file name.  A binary protocol buffer will be written\n",
      "            to this file.\n",
      "        export_params (bool, default True): if True, all parameters will\n",
      "            be exported. Set this to False if you want to export an untrained model.\n",
      "            In this case, the exported model will first take all of its parameters\n",
      "            as arguments, with the ordering as specified by ``model.state_dict().values()``\n",
      "        verbose (bool, default False): if True, prints a description of the\n",
      "            model being exported to stdout. In addition, the final ONNX graph will include the\n",
      "            field ``doc_string``` from the exported model which mentions the source code locations\n",
      "            for ``model``. If True, ONNX exporter logging will be turned on.\n",
      "        training (enum, default TrainingMode.EVAL):\n",
      "            * ``TrainingMode.EVAL``: export the model in inference mode.\n",
      "            * ``TrainingMode.PRESERVE``: export the model in inference mode if model.training is\n",
      "                False and in training mode if model.training is True.\n",
      "            * ``TrainingMode.TRAINING``: export the model in training mode. Disables optimizations\n",
      "                which might interfere with training.\n",
      "        input_names (list of str, default empty list): names to assign to the\n",
      "            input nodes of the graph, in order.\n",
      "        output_names (list of str, default empty list): names to assign to the\n",
      "            output nodes of the graph, in order.\n",
      "        operator_export_type (enum, default OperatorExportTypes.ONNX):\n",
      "    \n",
      "            * ``OperatorExportTypes.ONNX``: Export all ops as regular ONNX ops\n",
      "                (in the default opset domain).\n",
      "            * ``OperatorExportTypes.ONNX_FALLTHROUGH``: Try to convert all ops\n",
      "                to standard ONNX ops in the default opset domain. If unable to do so\n",
      "                (e.g. because support has not been added to convert a particular torch op to ONNX),\n",
      "                fall back to exporting the op into a custom opset domain without conversion. Applies\n",
      "                to `custom ops <https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html>`_\n",
      "                as well as ATen ops. For the exported model to be usable, the runtime must support\n",
      "                these non-standard ops.\n",
      "            * ``OperatorExportTypes.ONNX_ATEN``: All ATen ops (in the TorchScript namespace \"aten\")\n",
      "                are exported as ATen ops (in opset domain \"org.pytorch.aten\").\n",
      "                `ATen <https://pytorch.org/cppdocs/#aten>`_ is PyTorch's built-in tensor library, so\n",
      "                this instructs the runtime to use PyTorch's implementation of these ops.\n",
      "    \n",
      "                .. warning::\n",
      "    \n",
      "                    Models exported this way are probably runnable only by Caffe2.\n",
      "    \n",
      "                    This may be useful if the numeric differences in implementations of operators are\n",
      "                    causing large differences in behavior between PyTorch and Caffe2 (which is more\n",
      "                    common on untrained models).\n",
      "    \n",
      "            * ``OperatorExportTypes.ONNX_ATEN_FALLBACK``: Try to export each ATen op\n",
      "                (in the TorchScript namespace \"aten\") as a regular ONNX op. If we are unable to do so\n",
      "                (e.g. because support has not been added to convert a particular torch op to ONNX),\n",
      "                fall back to exporting an ATen op. See documentation on OperatorExportTypes.ONNX_ATEN for\n",
      "                context.\n",
      "                For example::\n",
      "    \n",
      "                    graph(%0 : Float):\n",
      "                    %3 : int = prim::Constant[value=0]()\n",
      "                    # conversion unsupported\n",
      "                    %4 : Float = aten::triu(%0, %3)\n",
      "                    # conversion supported\n",
      "                    %5 : Float = aten::mul(%4, %0)\n",
      "                    return (%5)\n",
      "    \n",
      "                Assuming ``aten::triu`` is not supported in ONNX, this will be exported as::\n",
      "    \n",
      "                    graph(%0 : Float):\n",
      "                    %1 : Long() = onnx::Constant[value={0}]()\n",
      "                    # not converted\n",
      "                    %2 : Float = aten::ATen[operator=\"triu\"](%0, %1)\n",
      "                    # converted\n",
      "                    %3 : Float = onnx::Mul(%2, %0)\n",
      "                    return (%3)\n",
      "    \n",
      "                If PyTorch was built with Caffe2 (i.e. with ``BUILD_CAFFE2=1``), then\n",
      "                Caffe2-specific behavior will be enabled, including special support\n",
      "                for ops are produced by the modules described in\n",
      "                `Quantization <https://pytorch.org/docs/stable/quantization.html>`_.\n",
      "    \n",
      "                .. warning::\n",
      "    \n",
      "                    Models exported this way are probably runnable only by Caffe2.\n",
      "    \n",
      "        opset_version (int, default 17): The version of the\n",
      "            `default (ai.onnx) opset <https://github.com/onnx/onnx/blob/master/docs/Operators.md>`_\n",
      "            to target. Must be >= 7 and <= 17.\n",
      "        do_constant_folding (bool, default True): Apply the constant-folding optimization.\n",
      "            Constant-folding will replace some of the ops that have all constant inputs\n",
      "            with pre-computed constant nodes.\n",
      "        dynamic_axes (dict[string, dict[int, string]] or dict[string, list(int)], default empty dict):\n",
      "    \n",
      "            By default the exported model will have the shapes of all input and output tensors\n",
      "            set to exactly match those given in ``args``. To specify axes of tensors as\n",
      "            dynamic (i.e. known only at run-time), set ``dynamic_axes`` to a dict with schema:\n",
      "    \n",
      "            * KEY (str): an input or output name. Each name must also be provided in ``input_names`` or\n",
      "                ``output_names``.\n",
      "            * VALUE (dict or list): If a dict, keys are axis indices and values are axis names. If a\n",
      "                list, each element is an axis index.\n",
      "    \n",
      "            For example::\n",
      "    \n",
      "                class SumModule(torch.nn.Module):\n",
      "                    def forward(self, x):\n",
      "                        return torch.sum(x, dim=1)\n",
      "    \n",
      "                torch.onnx.export(\n",
      "                    SumModule(),\n",
      "                    (torch.ones(2, 2),),\n",
      "                    \"onnx.pb\",\n",
      "                    input_names=[\"x\"],\n",
      "                    output_names=[\"sum\"]\n",
      "                )\n",
      "    \n",
      "            Produces::\n",
      "    \n",
      "                input {\n",
      "                  name: \"x\"\n",
      "                  ...\n",
      "                      shape {\n",
      "                        dim {\n",
      "                          dim_value: 2  # axis 0\n",
      "                        }\n",
      "                        dim {\n",
      "                          dim_value: 2  # axis 1\n",
      "                ...\n",
      "                output {\n",
      "                  name: \"sum\"\n",
      "                  ...\n",
      "                      shape {\n",
      "                        dim {\n",
      "                          dim_value: 2  # axis 0\n",
      "                ...\n",
      "    \n",
      "            While::\n",
      "    \n",
      "                torch.onnx.export(\n",
      "                    SumModule(),\n",
      "                    (torch.ones(2, 2),),\n",
      "                    \"onnx.pb\",\n",
      "                    input_names=[\"x\"],\n",
      "                    output_names=[\"sum\"],\n",
      "                    dynamic_axes={\n",
      "                        # dict value: manually named axes\n",
      "                        \"x\": {0: \"my_custom_axis_name\"},\n",
      "                        # list value: automatic names\n",
      "                        \"sum\": [0],\n",
      "                    }\n",
      "                )\n",
      "    \n",
      "            Produces::\n",
      "    \n",
      "                input {\n",
      "                  name: \"x\"\n",
      "                  ...\n",
      "                      shape {\n",
      "                        dim {\n",
      "                          dim_param: \"my_custom_axis_name\"  # axis 0\n",
      "                        }\n",
      "                        dim {\n",
      "                          dim_value: 2  # axis 1\n",
      "                ...\n",
      "                output {\n",
      "                  name: \"sum\"\n",
      "                  ...\n",
      "                      shape {\n",
      "                        dim {\n",
      "                          dim_param: \"sum_dynamic_axes_1\"  # axis 0\n",
      "                ...\n",
      "    \n",
      "        keep_initializers_as_inputs (bool, default None): If True, all the\n",
      "            initializers (typically corresponding to parameters) in the\n",
      "            exported graph will also be added as inputs to the graph. If False,\n",
      "            then initializers are not added as inputs to the graph, and only\n",
      "            the non-parameter inputs are added as inputs.\n",
      "            This may allow for better optimizations (e.g. constant folding) by\n",
      "            backends/runtimes.\n",
      "    \n",
      "            If True, `deduplicate_initializers` pass will not be executed. This means\n",
      "            initializers with duplicated values will not be deduplicated and\n",
      "            will be treated as distinct inputs to the graph. This allows different\n",
      "            input initializers to be supplied at the runtime following export.\n",
      "    \n",
      "            If ``opset_version < 9``, initializers MUST be part of graph\n",
      "            inputs and this argument will be ignored and the behavior will be\n",
      "            equivalent to setting this argument to True.\n",
      "    \n",
      "            If None, then the behavior is chosen automatically as follows:\n",
      "    \n",
      "            * If ``operator_export_type=OperatorExportTypes.ONNX``, the behavior is equivalent\n",
      "                to setting this argument to False.\n",
      "            * Else, the behavior is equivalent to setting this argument to True.\n",
      "    \n",
      "        custom_opsets (dict[str, int], default empty dict): A dict with schema:\n",
      "    \n",
      "            * KEY (str): opset domain name\n",
      "            * VALUE (int): opset version\n",
      "    \n",
      "            If a custom opset is referenced by ``model`` but not mentioned in this dictionary,\n",
      "            the opset version is set to 1. Only custom opset domain name and version should be\n",
      "            indicated through this argument.\n",
      "    \n",
      "        export_modules_as_functions (bool or set of type of nn.Module, default False): Flag to enable\n",
      "            exporting all ``nn.Module`` forward calls as local functions in ONNX. Or a set to indicate the\n",
      "            particular types of modules to export as local functions in ONNX.\n",
      "            This feature requires ``opset_version`` >= 15, otherwise the export will fail. This is because\n",
      "            ``opset_version`` < 15 implies IR version < 8, which means no local function support.\n",
      "            Module variables will be exported as function attributes. There are two categories of function\n",
      "            attributes.\n",
      "    \n",
      "            1. Annotated attributes: class variables that have type annotations via\n",
      "            `PEP 526-style <https://www.python.org/dev/peps/pep-0526/#class-and-instance-variable-annotations>`_\n",
      "            will be exported as attributes.\n",
      "            Annotated attributes are not used inside the subgraph of ONNX local function because\n",
      "            they are not created by PyTorch JIT tracing, but they may be used by consumers\n",
      "            to determine whether or not to replace the function with a particular fused kernel.\n",
      "    \n",
      "            2. Inferred attributes: variables that are used by operators inside the module. Attribute names\n",
      "            will have prefix \"inferred::\". This is to differentiate from predefined attributes retrieved from\n",
      "            python module annotations. Inferred attributes are used inside the subgraph of ONNX local function.\n",
      "    \n",
      "            * ``False`` (default): export ``nn.Module`` forward calls as fine grained nodes.\n",
      "            * ``True``: export all ``nn.Module`` forward calls as local function nodes.\n",
      "            * Set of type of nn.Module: export ``nn.Module`` forward calls as local function nodes,\n",
      "                only if the type of the ``nn.Module`` is found in the set.\n",
      "    \n",
      "        autograd_inlining (bool, default True): Flag used to control whether to inline autograd functions.\n",
      "            Refer to https://github.com/pytorch/pytorch/pull/74765 for more details.\n",
      "    \n",
      "    Raises:\n",
      "        :class:`torch.onnx.errors.CheckerError`: If the ONNX checker detects an invalid ONNX graph.\n",
      "        :class:`torch.onnx.errors.UnsupportedOperatorError`: If the ONNX graph cannot be exported because it\n",
      "            uses an operator that is not supported by the exporter.\n",
      "        :class:`torch.onnx.errors.OnnxExporterError`: Other errors that can occur during export.\n",
      "            All errors are subclasses of :class:`errors.OnnxExporterError`.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(torch.onnx.export)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "network_config_lan = pickle.load(\n",
    "    open(\n",
    "        \"../data/jax_models/\" + MODEL + \"/\" + MODEL + \"_jax_lan_network_config.pickle\",\n",
    "        \"rb\",\n",
    "    )\n",
    ")\n",
    "network_config_cpn = pickle.load(\n",
    "    open(\n",
    "        \"../data/jax_models/\" + MODEL + \"/\" + MODEL + \"_jax_cpn_network_config.pickle\",\n",
    "        \"rb\",\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "passing through identity\n",
      "passing through transform\n"
     ]
    }
   ],
   "source": [
    "# LAN\n",
    "jax_infer_lan = lanfactory.trainers.MLPJaxFactory(\n",
    "    network_config=network_config_lan,\n",
    "    train=False,\n",
    ")\n",
    "\n",
    "forward_lan, forward_jitted_lan = jax_infer_lan.make_forward_partial(\n",
    "    seed=42,\n",
    "    input_dim=ssms.config.model_config[MODEL][\"n_params\"] + 2,\n",
    "    state=\"../data/jax_models/\" + MODEL + \"/\" + MODEL + \"_jax_lan_train_state.jax\",\n",
    "    add_jitted=True,\n",
    ")\n",
    "\n",
    "# # CPN\n",
    "jax_infer_cpn = lanfactory.trainers.MLPJaxFactory(\n",
    "    network_config=network_config_cpn,\n",
    "    train=False,\n",
    ")\n",
    "\n",
    "forward_cpn, forward_jitted_cpn = jax_infer_cpn.make_forward_partial(\n",
    "    seed=42,\n",
    "    input_dim=ssms.config.model_config[MODEL][\"n_params\"],\n",
    "    state=\"../data/jax_models/\" + MODEL + \"/\" + MODEL + \"_jax_cpn_train_state.jax\",\n",
    "    add_jitted=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "passing through identity\n"
     ]
    }
   ],
   "source": [
    "# Plot LAN\n",
    "import jax.numpy as jnp\n",
    "\n",
    "# Test parameters:\n",
    "theta = deepcopy(ssms.config.model_config[MODEL][\"default_params\"])\n",
    "\n",
    "theta[0] = 0.2  # v\n",
    "theta[3] = 1.0  # t\n",
    "\n",
    "# Comparison simulator run\n",
    "sim_out = ssms.basic_simulators.simulator.simulator(\n",
    "    model=MODEL, theta=theta, n_samples=50000\n",
    ")\n",
    "\n",
    "# Make input metric\n",
    "input_mat = jnp.zeros((2000, len(theta) + 2))\n",
    "for i in range(len(theta)):\n",
    "    input_mat = input_mat.at[:, i].set(jnp.ones(2000) * theta[i])\n",
    "\n",
    "input_mat = input_mat.at[:, len(theta)].set(\n",
    "    jnp.array(\n",
    "        np.concatenate(\n",
    "            [\n",
    "                np.linspace(5, 0, 1000).astype(np.float32),\n",
    "                np.linspace(0, 5, 1000).astype(np.float32),\n",
    "            ]\n",
    "        )\n",
    "    )\n",
    ")\n",
    "input_mat = input_mat.at[:, len(theta) + 1].set(\n",
    "    jnp.array(\n",
    "        np.concatenate([np.repeat(-1.0, 1000), np.repeat(1.0, 1000)]).astype(np.float32)\n",
    "    )\n",
    ")\n",
    "\n",
    "net_out = forward_jitted_lan(input_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.plot(np.linspace(-5, 5, 2000).astype(np.float32), np.exp(net_out))\n",
    "\n",
    "plt.hist(\n",
    "    sim_out[\"rts\"] * sim_out[\"choices\"],\n",
    "    bins=100,\n",
    "    histtype=\"step\",\n",
    "    fill=None,\n",
    "    density=True,\n",
    ");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "passing through transform\n"
     ]
    }
   ],
   "source": [
    "# Plot CPN\n",
    "# Test parameters:\n",
    "# Test parameters:\n",
    "theta = deepcopy(ssms.config.model_config[MODEL][\"default_params\"])\n",
    "\n",
    "v = np.linspace(-3, 3, 50)\n",
    "\n",
    "# Comparison simulator run\n",
    "choice_p_list = []\n",
    "for v_tmp in v:\n",
    "    # print(v_tmp)\n",
    "    theta[0] = v_tmp\n",
    "    sim_out = ssms.basic_simulators.simulator.simulator(\n",
    "        model=MODEL, theta=theta, n_samples=5000\n",
    "    )\n",
    "    choice_p_list.append(\n",
    "        np.sum(sim_out[\"choices\"] == -1.0) / sim_out[\"choices\"].shape[0]\n",
    "    )\n",
    "\n",
    "    # NOTE: CPNs will be retrained to in fact give p of choice=1. That it's currently choice=-1\n",
    "    # is an unintended consequence of some changes to the ssms training data generators (already fixed)\n",
    "\n",
    "# Make input matric\n",
    "# NOTE: This part is unnecessarily specialized to DDM\n",
    "input_mat = jnp.zeros((50, 4))\n",
    "input_mat = input_mat.at[:, 0].set(jnp.array(v))\n",
    "input_mat = input_mat.at[:, 1].set(jnp.ones(50) * theta[1])\n",
    "input_mat = input_mat.at[:, 2].set(jnp.ones(50) * theta[2])\n",
    "input_mat = input_mat.at[:, 3].set(jnp.ones(50) * theta[3])\n",
    "\n",
    "net_out = forward_jitted_cpn(input_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'v')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.plot(input_mat.at[:, 0].set(jnp.array(v))[:, 0], choice_p_list)\n",
    "plt.plot(input_mat.at[:, 0].set(jnp.array(v))[:, 0], np.exp(net_out))\n",
    "plt.xlabel(\"v\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ssms_dev",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
